I'm using P2D as main renderer and the default for the Graphics object one because I whant to obtain a scaled pixel effect using the OpenGL nearest neighbor trick, but that same trick cannot be applied to a PGraphics rendering (so I use default + noSmooth() for this one). After Drawn everything on the PGraphic object, I scale the image on screen using the copy() method.

The result should be an image composed by PImage and PGraphics objects, but these last does not clean after a clear() or background(0,0) call so the image upon them is additive. The clear() call in particular gives me a tiny performances drop, while background(255,255) does its job so it's working fine as method.

I've tried every possible turnaround but nothing has the same performances/appearence as should be in this common way not working because of these problems. I don't know if I'm missing something or if I'm too stupid to figure out a simple solution.

here is a piece of the code that works on Java mode and does not work in Android mode:

pioggia.beginDraw();
pioggia.background(0,0);     //or clear()
for(int i = 0; i<gocceNum; i++){
   gocce[i][2] = (gocce[i][2]+gocceSpX*0.25)%back1.width;
   gocce[i][3] = (gocce[i][3]+gocceSpY*0.25)%back1.height;
   pioggia.set((int)gocce[i][2],(int)gocce[i][3], #355B4A);
}
pioggia.endDraw();
copy(pioggia, (int)quantize(disp*0.4, scalaH), 0, sw, sh, 0, 0, width, height);

"pioggia" is the PGraphics object, gocce is a 2D array of float values. Any help or hint would be super awesome ç_ç

PGraphics pg;
boolean controlDown = false;
boolean shiftDown = false;
int bgColor = 255;
int pColor = 0;
int pAlpha = 255;
int selector = 0;

int pSize = 5;
int eSize = 5;

boolean drawing = false;
boolean doOnce = false;

Undo undo;

void setup() {

  size(900, 600);
  smooth();

  pg = createGraphics(width, height);

  undo = new Undo(10);
}

void draw() {

  background(bgColor);

  if(mouseX > 142) {
    noCursor();
  } else {

    cursor();
  }

  noFill();
  stroke(0);  
  if(selector == 0) {

  ellipse(mouseX, mouseY, pSize + 2, pSize + 2);
  } else {

    ellipse(mouseX, mouseY, eSize + 2, eSize + 2);
  }
}

void pencil() {

  if (mousePressed) {

    if (mouseX > 142) {

      pg.beginDraw();
      pg.stroke(pColor, pAlpha);
      pg.strokeWeight(pSize);
      pg.strokeJoin(ROUND);
      pg.line(mouseX, mouseY, pmouseX, pmouseY);
      pg.endDraw();
      image(pg, 0, 0);
    }
  }
}



void mousePressed() {

  if (mouseX > 142) {

    drawing = true;
  } else {

    drawing = false;
  }
}

void mouseReleased() {

  drawing = false;
  doOnce = false;

  if(mouseX > 142 || mouseX > 18 && mouseX < 67 && mouseY > 534 && mouseY < 586) {

  undo.takeSnapshot();
  }
}

void mouseClicked() {

  println(mouseX, mouseY);
}

void keyPressed() {

  if (key == CODED) {

    if (keyCode == CONTROL) {

      controlDown = true;
    }
    if (keyCode == SHIFT) {

      shiftDown = true;
    }

    return;
  }

  if (controlDown) {

    if (keyCode == 'Z') {

      if (shiftDown) {

        undo.redo();
      } else {

        undo.undo();
      }
    }

    return;
  }
}

void keyReleased() {

  if (key == CODED) {

    if (keyCode == CONTROL) {

      controlDown = false;
    }

    if (keyCode == SHIFT) {

      shiftDown = false;
    }
  }
}


class Undo {

  int undoSteps = 0, redoSteps = 0; 

  CircImgCollection images;

  Undo(int levels) {

    images = new CircImgCollection(levels);
  }

  public void takeSnapshot(){

    undoSteps = min(undoSteps+1, images.amount-1);
    redoSteps = 0;
    images.next();
    images.capture();
  }

  public void undo() {

    if (undoSteps > 0) {

      undoSteps--;
      redoSteps++;
      images.prev();
      images.show();
    }
  }

  public void redo() {

    if (redoSteps > 0) {

      undoSteps++;
      redoSteps--;
      images.next();
      images.show();
    }
  }
}


class CircImgCollection {

  int amount, current;  
  PImage[] img;

  CircImgCollection(int amountOfImages) {

    amount = amountOfImages;

    img = new PImage[amount];

    for (int i=0; i < amount; i++) {

      img[i] = createImage(width, height, RGB);
      img[i] = get();
    }
  }

  void next() {

    current = (current + 1) % amount;
  }

  void prev() {

    current = (current - 1 + amount) % amount;
  }

  void capture() {

    img[current] = get();
  }

  void show() {

    image(img[current], 0, 0);
  }
}